// Decompiled by Jad v1.5.8f. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3) 

package jagex.client;

import jagex.DataOperations;
import java.io.*;

// Referenced classes of package jagex.client:
//            j

public class Model {

	public Model(int arg0, int arg1) {
		eh = 1;
		fh = true;
		mh = true;
		nh = false;
		oh = false;
		ph = -1;
		sh = false;
		th = false;
		uh = false;
		vh = false;
		wh = false;
		bi = 4;
		ci = 0xbc614e;
		ij = 0xbc614e;
		jj = 180;
		kj = 155;
		lj = 95;
		mj = 256;
		nj = 512;
		oj = 32;
		td(arg0, arg1);
		li = new int[arg1][1];
		for (int i = 0; i < arg1; i++) {
			li[i][0] = i;
		}

	}

	public Model(int arg0, int arg1, boolean arg2, boolean arg3, boolean arg4,
			boolean arg5, boolean arg6) {
		eh = 1;
		fh = true;
		mh = true;
		nh = false;
		oh = false;
		ph = -1;
		sh = false;
		th = false;
		uh = false;
		vh = false;
		wh = false;
		bi = 4;
		ci = 0xbc614e;
		ij = 0xbc614e;
		jj = 180;
		kj = 155;
		lj = 95;
		mj = 256;
		nj = 512;
		oj = 32;
		sh = arg2;
		th = arg3;
		uh = arg4;
		vh = arg5;
		wh = arg6;
		td(arg0, arg1);
	}

	private void td(int arg0, int arg1) {
		ei = new int[arg0];
		fi = new int[arg0];
		gi = new int[arg0];
		pg = new int[arg0];
		qg = new byte[arg0];
		sg = new int[arg1];
		tg = new int[arg1][];
		ug = new int[arg1];
		vg = new int[arg1];
		yg = new int[arg1];
		xg = new int[arg1];
		wg = new int[arg1];
		if (!wh) {
			kg = new int[arg0];
			lg = new int[arg0];
			mg = new int[arg0];
			ng = new int[arg0];
			og = new int[arg0];
		}
		if (!vh) {
			rh = new byte[arg1];
			qh = new int[arg1];
		}
		if (sh) {
			hi = ei;
			ii = fi;
			ji = gi;
		} else {
			hi = new int[arg0];
			ii = new int[arg0];
			ji = new int[arg0];
		}
		if (!uh || !th) {
			zg = new int[arg1];
			ah = new int[arg1];
			bh = new int[arg1];
		}
		if (!th) {
			mi = new int[arg1];
			ni = new int[arg1];
			oi = new int[arg1];
			pi = new int[arg1];
			qi = new int[arg1];
			ri = new int[arg1];
		}
		rg = 0;
		jg = 0;
		di = arg0;
		ki = arg1;
		si = ti = ui = 0;
		vi = wi = xi = 0;
		yi = zi = aj = 256;
		bj = cj = dj = ej = fj = gj = 256;
		hj = 0;
	}

	public void oe() {
		kg = new int[jg];
		lg = new int[jg];
		mg = new int[jg];
		ng = new int[jg];
		og = new int[jg];
	}

	public void re() {
		rg = 0;
		jg = 0;
	}

	public void ge(int arg0, int arg1) {
		rg -= arg0;
		if (rg < 0) {
			rg = 0;
		}
		jg -= arg1;
		if (jg < 0) {
			jg = 0;
		}
	}

	public Model(byte arg0[], int arg1) {
		eh = 1;
		fh = true;
		mh = true;
		nh = false;
		oh = false;
		ph = -1;
		sh = false;
		th = false;
		uh = false;
		vh = false;
		wh = false;
		bi = 4;
		ci = 0xbc614e;
		ij = 0xbc614e;
		jj = 180;
		kj = 155;
		lj = 95;
		mj = 256;
		nj = 512;
		oj = 32;
		pj = arg0;
		qj = arg1;
		rj = 0;
		me(pj);
		int i = me(pj);
		int k = me(pj);
		boolean flag = false;
		td(i, k);
		li = new int[k][];
		for (int l2 = 0; l2 < i; l2++) {
			int l = me(pj);
			int i1 = me(pj);
			int j1 = me(pj);
			je(l, i1, j1);
		}

		for (int i3 = 0; i3 < k; i3++) {
			int k1 = me(pj);
			int l1 = me(pj);
			int i2 = me(pj);
			int j2 = me(pj);
			nj = me(pj);
			oj = me(pj);
			int k2 = me(pj);
			int ai1[] = new int[k1];
			for (int j3 = 0; j3 < k1; j3++) {
				ai1[j3] = me(pj);
			}

			int ai2[] = new int[j2];
			for (int k3 = 0; k3 < j2; k3++) {
				ai2[k3] = me(pj);
			}

			int l3 = ie(k1, ai1, l1, i2);
			li[i3] = ai2;
			if (k2 == 0) {
				yg[l3] = 0;
			} else {
				yg[l3] = ci;
			}
		}

		eh = 1;
	}

	public Model(String arg0) {
		eh = 1;
		fh = true;
		mh = true;
		nh = false;
		oh = false;
		ph = -1;
		sh = false;
		th = false;
		uh = false;
		vh = false;
		wh = false;
		bi = 4;
		ci = 0xbc614e;
		ij = 0xbc614e;
		jj = 180;
		kj = 155;
		lj = 95;
		mj = 256;
		nj = 512;
		oj = 32;
		boolean flag = false;
		boolean flag1 = false;
		byte abyte0[] = null;
		try {
			java.io.InputStream inputstream = DataOperations
					.streamFromPath(arg0);
			DataInputStream datainputstream = new DataInputStream(inputstream);
			abyte0 = new byte[3];
			qj = 0;
			rj = 0;
			for (int i = 0; i < 3; i += datainputstream.read(abyte0, i, 3 - i)) {
				;
			}
			int l = me(abyte0);
			abyte0 = new byte[l];
			qj = 0;
			rj = 0;
			for (int k = 0; k < l; k += datainputstream.read(abyte0, k, l - k)) {
				;
			}
			datainputstream.close();
		} catch (IOException _ex) {
			jg = 0;
			rg = 0;
			return;
		}
		int i1 = me(abyte0);
		int j1 = me(abyte0);
		boolean flag2 = false;
		td(i1, j1);
		li = new int[j1][];
		for (int k3 = 0; k3 < i1; k3++) {
			int k1 = me(abyte0);
			int l1 = me(abyte0);
			int i2 = me(abyte0);
			je(k1, l1, i2);
		}

		for (int l3 = 0; l3 < j1; l3++) {
			int j2 = me(abyte0);
			int k2 = me(abyte0);
			int l2 = me(abyte0);
			int i3 = me(abyte0);
			nj = me(abyte0);
			oj = me(abyte0);
			int j3 = me(abyte0);
			int ai1[] = new int[j2];
			for (int i4 = 0; i4 < j2; i4++) {
				ai1[i4] = me(abyte0);
			}

			int ai2[] = new int[i3];
			for (int j4 = 0; j4 < i3; j4++) {
				ai2[j4] = me(abyte0);
			}

			int k4 = ie(j2, ai1, k2, l2);
			li[l3] = ai2;
			if (j3 == 0) {
				yg[k4] = 0;
			} else {
				yg[k4] = ci;
			}
		}

		eh = 1;
	}

	public Model(Model arg0[], int arg1) {
		eh = 1;
		fh = true;
		mh = true;
		nh = false;
		oh = false;
		ph = -1;
		sh = false;
		th = false;
		uh = false;
		vh = false;
		wh = false;
		bi = 4;
		ci = 0xbc614e;
		ij = 0xbc614e;
		jj = 180;
		kj = 155;
		lj = 95;
		mj = 256;
		nj = 512;
		oj = 32;
		be(arg0, arg1, true);
	}

	public void be(Model arg0[], int arg1, boolean arg2) {
		int i = 0;
		int k = 0;
		for (int l = 0; l < arg1; l++) {
			i += arg0[l].rg;
			k += arg0[l].jg;
		}

		td(k, i);
		if (arg2) {
			li = new int[i][];
		}
		for (int i1 = 0; i1 < arg1; i1++) {
			Model h1 = arg0[i1];
			h1.ee();
			oj = h1.oj;
			nj = h1.nj;
			jj = h1.jj;
			kj = h1.kj;
			lj = h1.lj;
			mj = h1.mj;
			for (int j1 = 0; j1 < h1.rg; j1++) {
				int ai1[] = new int[h1.sg[j1]];
				int ai2[] = h1.tg[j1];
				for (int k1 = 0; k1 < h1.sg[j1]; k1++) {
					ai1[k1] = je(h1.ei[ai2[k1]], h1.fi[ai2[k1]], h1.gi[ai2[k1]]);
				}

				int l1 = ie(h1.sg[j1], ai1, h1.ug[j1], h1.vg[j1]);
				yg[l1] = h1.yg[j1];
				xg[l1] = h1.xg[j1];
				wg[l1] = h1.wg[j1];
				if (arg2) {
					if (arg1 > 1) {
						li[l1] = new int[h1.li[j1].length + 1];
						li[l1][0] = i1;
						for (int i2 = 0; i2 < h1.li[j1].length; i2++) {
							li[l1][i2 + 1] = h1.li[j1][i2];
						}

					} else {
						li[l1] = new int[h1.li[j1].length];
						for (int j2 = 0; j2 < h1.li[j1].length; j2++) {
							li[l1][j2] = h1.li[j1][j2];
						}

					}
				}
			}

		}

		eh = 1;
	}

	public int je(int arg0, int arg1, int arg2) {
		for (int i = 0; i < jg; i++) {
			if (ei[i] == arg0 && fi[i] == arg1 && gi[i] == arg2) {
				return i;
			}
		}

		if (jg >= di) {
			return -1;
		} else {
			ei[jg] = arg0;
			fi[jg] = arg1;
			gi[jg] = arg2;
			return jg++;
		}
	}

	public int zd(int arg0, int arg1, int arg2) {
		if (jg >= di) {
			return -1;
		} else {
			ei[jg] = arg0;
			fi[jg] = arg1;
			gi[jg] = arg2;
			return jg++;
		}
	}

	public int ie(int arg0, int arg1[], int arg2, int arg3) {
		if (rg >= ki) {
			return -1;
		} else {
			sg[rg] = arg0;
			tg[rg] = arg1;
			ug[rg] = arg2;
			vg[rg] = arg3;
			eh = 1;
			return rg++;
		}
	}

	public Model[] rd(int arg0, int arg1, int arg2, int arg3, int arg4,
			int arg5, int arg6, boolean arg7) {
		ee();
		int ai1[] = new int[arg5];
		int ai2[] = new int[arg5];
		for (int i = 0; i < arg5; i++) {
			ai1[i] = 0;
			ai2[i] = 0;
		}

		for (int k = 0; k < rg; k++) {
			int l = 0;
			int i1 = 0;
			int k1 = sg[k];
			int ai3[] = tg[k];
			for (int k2 = 0; k2 < k1; k2++) {
				l += ei[ai3[k2]];
				i1 += gi[ai3[k2]];
			}

			int i3 = l / (k1 * arg2) + (i1 / (k1 * arg3)) * arg4;
			ai1[i3] += k1;
			ai2[i3]++;
		}

		Model ah1[] = new Model[arg5];
		for (int j1 = 0; j1 < arg5; j1++) {
			if (ai1[j1] > arg6) {
				ai1[j1] = arg6;
			}
			ah1[j1] = new Model(ai1[j1], ai2[j1], true, true, true, arg7, true);
			ah1[j1].nj = nj;
			ah1[j1].oj = oj;
		}

		for (int l1 = 0; l1 < rg; l1++) {
			int i2 = 0;
			int l2 = 0;
			int j3 = sg[l1];
			int ai4[] = tg[l1];
			for (int k3 = 0; k3 < j3; k3++) {
				i2 += ei[ai4[k3]];
				l2 += gi[ai4[k3]];
			}

			int l3 = i2 / (j3 * arg2) + (l2 / (j3 * arg3)) * arg4;
			te(ah1[l3], ai4, j3, l1);
		}

		for (int j2 = 0; j2 < arg5; j2++) {
			ah1[j2].oe();
		}

		return ah1;
	}

	public void te(Model arg0, int arg1[], int arg2, int arg3) {
		int ai1[] = new int[arg2];
		for (int i = 0; i < arg2; i++) {
			int k = ai1[i] = arg0.je(ei[arg1[i]], fi[arg1[i]], gi[arg1[i]]);
			arg0.pg[k] = pg[arg1[i]];
			arg0.qg[k] = qg[arg1[i]];
		}

		int l = arg0.ie(arg2, ai1, ug[arg3], vg[arg3]);
		if (!arg0.vh && !vh) {
			arg0.qh[l] = qh[arg3];
		}
		arg0.yg[l] = yg[arg3];
		arg0.xg[l] = xg[arg3];
		arg0.wg[l] = wg[arg3];
	}

	public void ne(boolean arg0, int arg1, int arg2, int arg3, int arg4,
			int arg5) {
		oj = 256 - arg1 * 4;
		nj = (64 - arg2) * 16 + 128;
		if (uh) {
			return;
		}
		for (int i = 0; i < rg; i++) {
			if (arg0) {
				yg[i] = ci;
			} else {
				yg[i] = 0;
			}
		}

		jj = arg3;
		kj = arg4;
		lj = arg5;
		mj = (int) Math.sqrt(arg3 * arg3 + arg4 * arg4 + arg5 * arg5);
		he();
	}

	public void se(int arg0, int arg1, int arg2) {
		if (uh) {
			return;
		} else {
			jj = arg0;
			kj = arg1;
			lj = arg2;
			mj = (int) Math.sqrt(arg0 * arg0 + arg1 * arg1 + arg2 * arg2);
			he();
			return;
		}
	}

	public void ud(int arg0, int arg1) {
		qg[arg0] = (byte) arg1;
	}

	public void pe(int arg0, int arg1, int arg2) {
		vi = vi + arg0 & 0xff;
		wi = wi + arg1 & 0xff;
		xi = xi + arg2 & 0xff;
		qe();
		eh = 1;
	}

	public void wd(int arg0, int arg1, int arg2) {
		si += arg0;
		ti += arg1;
		ui += arg2;
		qe();
		eh = 1;
	}

	public void ce(int arg0, int arg1, int arg2) {
		si = arg0;
		ti = arg1;
		ui = arg2;
		qe();
		eh = 1;
	}

	public int ue() {
		return si;
	}

	public void sd(int arg0, int arg1, int arg2) {
		yi = arg0;
		zi = arg1;
		aj = arg2;
		qe();
		eh = 1;
	}

	public void xd(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5) {
		bj = arg0;
		cj = arg1;
		dj = arg2;
		ej = arg3;
		fj = arg4;
		gj = arg5;
		qe();
		eh = 1;
	}

	private void qe() {
		if (bj != 256 || cj != 256 || dj != 256 || ej != 256 || fj != 256
				|| gj != 256) {
			hj = 4;
			return;
		}
		if (yi != 256 || zi != 256 || aj != 256) {
			hj = 3;
			return;
		}
		if (vi != 0 || wi != 0 || xi != 0) {
			hj = 2;
			return;
		}
		if (si != 0 || ti != 0 || ui != 0) {
			hj = 1;
			return;
		} else {
			hj = 0;
			return;
		}
	}

	private void ve(int arg0, int arg1, int arg2) {
		for (int i = 0; i < jg; i++) {
			hi[i] += arg0;
			ii[i] += arg1;
			ji[i] += arg2;
		}

	}

	private void ae(int arg0, int arg1, int arg2) {
		for (int k2 = 0; k2 < jg; k2++) {
			if (arg2 != 0) {
				int i = xh[arg2];
				int i1 = xh[arg2 + 256];
				int l1 = ii[k2] * i + hi[k2] * i1 >> 15;
				ii[k2] = ii[k2] * i1 - hi[k2] * i >> 15;
				hi[k2] = l1;
			}
			if (arg0 != 0) {
				int k = xh[arg0];
				int j1 = xh[arg0 + 256];
				int i2 = ii[k2] * j1 - ji[k2] * k >> 15;
				ji[k2] = ii[k2] * k + ji[k2] * j1 >> 15;
				ii[k2] = i2;
			}
			if (arg1 != 0) {
				int l = xh[arg1];
				int k1 = xh[arg1 + 256];
				int j2 = ji[k2] * l + hi[k2] * k1 >> 15;
				ji[k2] = ji[k2] * k1 - hi[k2] * l >> 15;
				hi[k2] = j2;
			}
		}

	}

	private void yd(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5) {
		for (int i = 0; i < jg; i++) {
			if (arg0 != 0) {
				hi[i] += ii[i] * arg0 >> 8;
			}
			if (arg1 != 0) {
				ji[i] += ii[i] * arg1 >> 8;
			}
			if (arg2 != 0) {
				hi[i] += ji[i] * arg2 >> 8;
			}
			if (arg3 != 0) {
				ii[i] += ji[i] * arg3 >> 8;
			}
			if (arg4 != 0) {
				ji[i] += hi[i] * arg4 >> 8;
			}
			if (arg5 != 0) {
				ii[i] += hi[i] * arg5 >> 8;
			}
		}

	}

	private void fe(int arg0, int arg1, int arg2) {
		for (int i = 0; i < jg; i++) {
			hi[i] = hi[i] * arg0 >> 8;
			ii[i] = ii[i] * arg1 >> 8;
			ji[i] = ji[i] * arg2 >> 8;
		}

	}

	private void qd() {
		gh = ih = kh = 0xf423f;
		ij = hh = jh = lh = 0xfff0bdc1;
		for (int i = 0; i < rg; i++) {
			int ai1[] = tg[i];
			int l = ai1[0];
			int j1 = sg[i];
			int k1;
			int l1 = k1 = hi[l];
			int i2;
			int j2 = i2 = ii[l];
			int k2;
			int l2 = k2 = ji[l];
			for (int k = 0; k < j1; k++) {
				int i1 = ai1[k];
				if (hi[i1] < k1) {
					k1 = hi[i1];
				} else if (hi[i1] > l1) {
					l1 = hi[i1];
				}
				if (ii[i1] < i2) {
					i2 = ii[i1];
				} else if (ii[i1] > j2) {
					j2 = ii[i1];
				}
				if (ji[i1] < k2) {
					k2 = ji[i1];
				} else if (ji[i1] > l2) {
					l2 = ji[i1];
				}
			}

			if (!th) {
				mi[i] = k1;
				ni[i] = l1;
				oi[i] = i2;
				pi[i] = j2;
				qi[i] = k2;
				ri[i] = l2;
			}
			if (l1 - k1 > ij) {
				ij = l1 - k1;
			}
			if (j2 - i2 > ij) {
				ij = j2 - i2;
			}
			if (l2 - k2 > ij) {
				ij = l2 - k2;
			}
			if (k1 < gh) {
				gh = k1;
			}
			if (l1 > hh) {
				hh = l1;
			}
			if (i2 < ih) {
				ih = i2;
			}
			if (j2 > jh) {
				jh = j2;
			}
			if (k2 < kh) {
				kh = k2;
			}
			if (l2 > lh) {
				lh = l2;
			}
		}

	}

	public void he() {
		if (uh) {
			return;
		}
		int i = nj * mj >> 8;
		for (int k = 0; k < rg; k++) {
			if (yg[k] != ci) {
				yg[k] = (zg[k] * jj + ah[k] * kj + bh[k] * lj) / i;
			}
		}

		int ai1[] = new int[jg];
		int ai2[] = new int[jg];
		int ai3[] = new int[jg];
		int ai4[] = new int[jg];
		for (int l = 0; l < jg; l++) {
			ai1[l] = 0;
			ai2[l] = 0;
			ai3[l] = 0;
			ai4[l] = 0;
		}

		for (int i1 = 0; i1 < rg; i1++) {
			if (yg[i1] == ci) {
				for (int j1 = 0; j1 < sg[i1]; j1++) {
					int l1 = tg[i1][j1];
					ai1[l1] += zg[i1];
					ai2[l1] += ah[i1];
					ai3[l1] += bh[i1];
					ai4[l1]++;
				}

			}
		}

		for (int k1 = 0; k1 < jg; k1++) {
			if (ai4[k1] > 0) {
				pg[k1] = (ai1[k1] * jj + ai2[k1] * kj + ai3[k1] * lj)
						/ (i * ai4[k1]);
			}
		}

	}

	public void ke() {
		if (uh && th) {
			return;
		}
		for (int i = 0; i < rg; i++) {
			int ai1[] = tg[i];
			int k = hi[ai1[0]];
			int l = ii[ai1[0]];
			int i1 = ji[ai1[0]];
			int j1 = hi[ai1[1]] - k;
			int k1 = ii[ai1[1]] - l;
			int l1 = ji[ai1[1]] - i1;
			int i2 = hi[ai1[2]] - k;
			int j2 = ii[ai1[2]] - l;
			int k2 = ji[ai1[2]] - i1;
			int l2 = k1 * k2 - j2 * l1;
			int i3 = l1 * i2 - k2 * j1;
			int j3;
			for (j3 = j1 * j2 - i2 * k1; l2 > 8192 || i3 > 8192 || j3 > 8192
					|| l2 < -8192 || i3 < -8192 || j3 < -8192; j3 >>= 1) {
				l2 >>= 1;
				i3 >>= 1;
			}

			int k3 = (int) (256D * Math.sqrt(l2 * l2 + i3 * i3 + j3 * j3));
			if (k3 <= 0) {
				k3 = 1;
			}
			zg[i] = (l2 * 0x10000) / k3;
			ah[i] = (i3 * 0x10000) / k3;
			bh[i] = (j3 * 65535) / k3;
			xg[i] = -1;
		}

		he();
	}

	public void pd() {
		if (eh == 2) {
			eh = 0;
			for (int i = 0; i < jg; i++) {
				hi[i] = ei[i];
				ii[i] = fi[i];
				ji[i] = gi[i];
			}

			gh = ih = kh = 0xff676981;
			ij = hh = jh = lh = 0x98967f;
			return;
		}
		if (eh == 1) {
			eh = 0;
			for (int k = 0; k < jg; k++) {
				hi[k] = ei[k];
				ii[k] = fi[k];
				ji[k] = gi[k];
			}

			if (hj >= 2) {
				ae(vi, wi, xi);
			}
			if (hj >= 3) {
				fe(yi, zi, aj);
			}
			if (hj >= 4) {
				yd(bj, cj, dj, ej, fj, gj);
			}
			if (hj >= 1) {
				ve(si, ti, ui);
			}
			qd();
			ke();
		}
	}

	public void de(int arg0, int arg1, int arg2, int arg3, int arg4, int arg5,
			int arg6, int arg7) {
		pd();
		if (kh > Camera.ep || lh < Camera.dp || gh > Camera.ap
				|| hh < Camera.zo || ih > Camera.cp || jh < Camera.bp) {
			fh = false;
			return;
		}
		fh = true;
		int i1 = 0;
		int j1 = 0;
		int k1 = 0;
		int l1 = 0;
		int i2 = 0;
		int j2 = 0;
		if (arg5 != 0) {
			i1 = yh[arg5];
			j1 = yh[arg5 + 1024];
		}
		if (arg4 != 0) {
			i2 = yh[arg4];
			j2 = yh[arg4 + 1024];
		}
		if (arg3 != 0) {
			k1 = yh[arg3];
			l1 = yh[arg3 + 1024];
		}
		for (int k2 = 0; k2 < jg; k2++) {
			int l2 = hi[k2] - arg0;
			int i3 = ii[k2] - arg1;
			int j3 = ji[k2] - arg2;
			if (arg5 != 0) {
				int i = i3 * i1 + l2 * j1 >> 15;
				i3 = i3 * j1 - l2 * i1 >> 15;
				l2 = i;
			}
			if (arg4 != 0) {
				int k = j3 * i2 + l2 * j2 >> 15;
				j3 = j3 * j2 - l2 * i2 >> 15;
				l2 = k;
			}
			if (arg3 != 0) {
				int l = i3 * l1 - j3 * k1 >> 15;
				j3 = i3 * k1 + j3 * l1 >> 15;
				i3 = l;
			}
			if (j3 >= arg7) {
				ng[k2] = (l2 << arg6) / j3;
			} else {
				ng[k2] = l2 << arg6;
			}
			if (j3 >= arg7) {
				og[k2] = (i3 << arg6) / j3;
			} else {
				og[k2] = i3 << arg6;
			}
			kg[k2] = l2;
			lg[k2] = i3;
			mg[k2] = j3;
		}

	}

	public void ee() {
		pd();
		for (int i = 0; i < jg; i++) {
			ei[i] = hi[i];
			fi[i] = ii[i];
			gi[i] = ji[i];
		}

		si = ti = ui = 0;
		vi = wi = xi = 0;
		yi = zi = aj = 256;
		bj = cj = dj = ej = fj = gj = 256;
		hj = 0;
	}

	public Model le() {
		Model ah1[] = new Model[1];
		ah1[0] = this;
		Model h1 = new Model(ah1, 1);
		h1.dh = dh;
		return h1;
	}

	public void vd(Model arg0) {
		vi = arg0.vi;
		wi = arg0.wi;
		xi = arg0.xi;
		si = arg0.si;
		ti = arg0.ti;
		ui = arg0.ui;
		qe();
		eh = 1;
	}

	public int me(byte arg0[]) {
		for (; arg0[qj] == 10 || arg0[qj] == 13; qj++) {
			;
		}
		int i = ai[arg0[qj++] & 0xff];
		int k = ai[arg0[qj++] & 0xff];
		int l = ai[arg0[qj++] & 0xff];
		int i1 = (i * 4096 + k * 64 + l) - 0x20000;
		if (i1 == 0x1e240) {
			i1 = ci;
		}
		return i1;
	}

	public int jg;
	public int kg[];
	public int lg[];
	public int mg[];
	public int ng[];
	public int og[];
	public int pg[];
	public byte qg[];
	public int rg;
	public int sg[];
	public int tg[][];
	public int ug[];
	public int vg[];
	public int wg[];
	public int xg[];
	public int yg[];
	public int zg[];
	public int ah[];
	public int bh[];
	public int ch;
	public int dh;
	public int eh;
	public boolean fh;
	public int gh;
	public int hh;
	public int ih;
	public int jh;
	public int kh;
	public int lh;
	public boolean mh;
	public boolean nh;
	public boolean oh;
	public int ph;
	public int qh[];
	public byte rh[];
	private boolean sh;
	public boolean th;
	public boolean uh;
	public boolean vh;
	public boolean wh;
	private static int xh[];
	private static int yh[];
	private static byte zh[];
	private static int ai[];
	private int bi;
	private int ci;
	public int di;
	public int ei[];
	public int fi[];
	public int gi[];
	public int hi[];
	public int ii[];
	public int ji[];
	private int ki;
	private int li[][];
	private int mi[];
	private int ni[];
	private int oi[];
	private int pi[];
	private int qi[];
	private int ri[];
	private int si;
	private int ti;
	private int ui;
	private int vi;
	private int wi;
	private int xi;
	private int yi;
	private int zi;
	private int aj;
	private int bj;
	private int cj;
	private int dj;
	private int ej;
	private int fj;
	private int gj;
	private int hj;
	private int ij;
	private int jj;
	private int kj;
	private int lj;
	private int mj;
	protected int nj;
	protected int oj;
	private byte pj[];
	private int qj;
	private int rj;

	static {
		xh = new int[512];
		yh = new int[2048];
		zh = new byte[64];
		ai = new int[256];
		for (int i = 0; i < 256; i++) {
			xh[i] = (int) (Math.sin((double) i * 0.02454369D) * 32768D);
			xh[i + 256] = (int) (Math.cos((double) i * 0.02454369D) * 32768D);
		}

		for (int k = 0; k < 1024; k++) {
			yh[k] = (int) (Math.sin((double) k * 0.00613592315D) * 32768D);
			yh[k + 1024] = (int) (Math.cos((double) k * 0.00613592315D) * 32768D);
		}

		for (int l = 0; l < 10; l++) {
			zh[l] = (byte) (48 + l);
		}

		for (int i1 = 0; i1 < 26; i1++) {
			zh[i1 + 10] = (byte) (65 + i1);
		}

		for (int j1 = 0; j1 < 26; j1++) {
			zh[j1 + 36] = (byte) (97 + j1);
		}

		zh[62] = -93;
		zh[63] = 36;
		for (int k1 = 0; k1 < 10; k1++) {
			ai[48 + k1] = k1;
		}

		for (int l1 = 0; l1 < 26; l1++) {
			ai[65 + l1] = l1 + 10;
		}

		for (int i2 = 0; i2 < 26; i2++) {
			ai[97 + i2] = i2 + 36;
		}

		ai[163] = 62;
		ai[36] = 63;
	}
}
